const express = require('express');
const router = express.Router();
const Category = require('../models/Category');
const Icon = require('../models/icon');

// 获取所有图标
router.get('/icons', async (req, res) => {
    try {
        console.log('开始获取图标...');
        const icons = await Icon.find({});
        console.log('获取到的图标:', icons);
        res.json(icons);
    } catch (error) {
        console.error('获取图标失败:', error);
        res.status(500).json({ message: '获取图标失败' });
    }
});

// 获取所有类别
router.get('/categories', async (req, res) => {
    try {
        console.log('收到获取类别请求');
        const { type } = req.query;
        let query = {};
        if (type) {
            query.type = type;
        }
        console.log('查询条件:', query);
        
        // 检查数据库连接状态
        const dbState = Category.db.readyState;
        console.log('数据库连接状态:', dbState);
        
        // 尝试获取所有类别
        console.log('开始查询数据库...');
        const categories = await Category.find(query).sort({ order: 1 });
        console.log('查询结果:', categories);
        
        if (!categories || categories.length === 0) {
            console.log('没有找到任何类别数据');
            return res.json([]);
        }
        
        res.json(categories);
    } catch (error) {
        console.error('获取类别数据失败:', error);
        console.error('错误详情:', {
            name: error.name,
            message: error.message,
            stack: error.stack
        });
        res.status(500).json({ 
            message: '获取类别数据失败', 
            error: error.message,
            details: error.stack
        });
    }
});

// 添加类别
router.post('/categories', async (req, res) => {
    try {
        console.log('收到添加类别请求，请求体:', JSON.stringify(req.body, null, 2));
        const { name, icon, type, order } = req.body;
        
        // 验证数据
        if (!name || !icon || !type) {
            console.log('验证失败，缺少必需字段:', { name, icon, type });
            return res.status(400).json({ 
                message: '添加类别失败', 
                error: '缺少必需字段',
                details: {
                    name: !name ? '缺少类别名称' : null,
                    icon: !icon ? '缺少图标' : null,
                    type: !type ? '缺少类型' : null
                }
            });
        }

        // 生成ID
        const id = `${type}_${name.toLowerCase().replace(/\s+/g, '_')}`;
        console.log('生成的ID:', id);

        // 创建新类别
        const categoryData = { 
            name, 
            icon, 
            type, 
            order: order || 0,
            id,
            data: [] // 初始化空的数据数组
        };
        
        console.log('准备创建的类别数据:', JSON.stringify(categoryData, null, 2));
        
        // 创建新类别实例
        const category = new Category(categoryData);
        console.log('创建的类别实例:', JSON.stringify(category, null, 2));
        
        // 保存到数据库
        const savedCategory = await category.save();
        console.log('类别保存成功:', JSON.stringify(savedCategory, null, 2));
        
        res.status(201).json(savedCategory);
    } catch (error) {
        console.error('添加类别失败，错误详情:', {
            name: error.name,
            message: error.message,
            stack: error.stack,
            code: error.code
        });
        
        // 处理 Mongoose 验证错误
        if (error.name === 'ValidationError') {
            console.error('Mongoose 验证错误:', error.errors);
            return res.status(400).json({
                message: '添加类别失败',
                error: '数据验证失败',
                details: Object.keys(error.errors).reduce((acc, key) => {
                    acc[key] = error.errors[key].message;
                    return acc;
                }, {})
            });
        }
        
        res.status(400).json({ 
            message: '添加类别失败', 
            error: error.message,
            details: error.stack
        });
    }
});

// 更新类别
router.put('/categories/:id', async (req, res) => {
    try {
        console.log('收到更新类别请求:', {
            id: req.params.id,
            body: req.body
        });

        // 验证请求数据
        if (!req.body || !req.body.data) {
            console.error('无效的请求数据');
            return res.status(400).json({
                success: false,
                message: '无效的请求数据',
                details: '请求体必须包含 data 字段'
            });
        }

        // 查找并更新类别
        const category = await Category.findByIdAndUpdate(
            req.params.id,
            req.body,
            { new: true, runValidators: true }
        );

        if (!category) {
            console.error('类别不存在:', req.params.id);
            return res.status(404).json({
                success: false,
                message: '类别不存在',
                details: `未找到ID为 ${req.params.id} 的类别`
            });
        }

        console.log('类别更新成功:', category);
        res.json({
            success: true,
            message: '更新成功',
            data: category
        });
    } catch (error) {
        console.error('更新类别失败:', {
            error: error.message,
            stack: error.stack,
            details: error
        });
        res.status(400).json({
            success: false,
            message: '更新类别失败',
            error: error.message,
            details: error.stack
        });
    }
});

// 更新类别顺序
router.put('/categories/reorder', async (req, res) => {
    try {
        const { categories } = req.body;
        for (const item of categories) {
            await Category.findByIdAndUpdate(item._id, { order: item.order });
        }
        res.json({ message: '更新成功' });
    } catch (error) {
        res.status(400).json({ message: '更新失败' });
    }
});

// 删除类别
router.delete('/categories/:id', async (req, res) => {
    try {
        console.log('收到删除类别请求:', {
            id: req.params.id
        });

        // 先检查类别是否存在
        const category = await Category.findById(req.params.id);
        if (!category) {
            console.error('类别不存在:', req.params.id);
            return res.status(404).json({
                success: false,
                message: '类别不存在',
                details: `未找到ID为 ${req.params.id} 的类别`
            });
        }

        // 执行删除操作
        const deletedCategory = await Category.findByIdAndDelete(req.params.id);
        console.log('类别删除成功:', deletedCategory);

        res.json({
            success: true,
            message: '删除成功',
            data: deletedCategory
        });
    } catch (error) {
        console.error('删除类别失败:', {
            error: error.message,
            stack: error.stack,
            details: error
        });
        res.status(500).json({
            success: false,
            message: '删除类别失败',
            error: error.message,
            details: error.stack
        });
    }
});

// 更新类别顺序
router.post('/updateOrder', async (req, res) => {
    try {
        const { type, categories } = req.body;
        
        // 验证数据
        if (!type || !Array.isArray(categories)) {
            return res.status(400).json({ 
                success: false,
                message: '无效的数据格式',
                details: '必须提供 type 和 categories 数组'
            });
        }

        // 验证每个类别的数据
        for (const category of categories) {
            if (!category._id || typeof category.order !== 'number') {
                return res.status(400).json({ 
                    success: false,
                    message: '无效的类别数据',
                    details: '每个类别必须包含 _id 和 order 字段，且 order 必须是数字'
                });
            }
        }

        // 构建批量更新操作
        const operations = categories.map(({ _id, order }) => ({
            updateOne: {
                filter: { _id, type }, // 同时匹配id和type，确保安全
                update: { $set: { order } }
            }
        }));

        // 执行批量更新
        const result = await Category.bulkWrite(operations);
        
        if (result.modifiedCount === 0) {
            return res.status(404).json({ 
                success: false,
                message: '没有找到需要更新的类别' 
            });
        }

        res.json({ 
            success: true,
            message: '排序更新成功',
            modifiedCount: result.modifiedCount
        });
    } catch (error) {
        console.error('更新排序失败:', error);
        res.status(500).json({ 
            success: false,
            message: '更新排序失败', 
            error: error.message 
        });
    }
});

// 检查类别名称是否存在
router.get('/check', async (req, res) => {
    try {
        const { name, type } = req.query;
        
        if (!name || !type) {
            return res.status(400).json({ 
                message: '缺少必要参数',
                details: '必须提供 name 和 type 参数'
            });
        }

        // 生成ID
        const id = `${type}_${name.toLowerCase().replace(/\s+/g, '_')}`;
        
        // 检查是否存在
        const existingCategory = await Category.findOne({ id });
        
        res.json({ 
            exists: !!existingCategory,
            message: existingCategory ? '类别名称已存在' : '类别名称可用'
        });
    } catch (error) {
        console.error('检查类别名称失败:', error);
        res.status(500).json({ 
            message: '检查类别名称失败', 
            error: error.message 
        });
    }
});

module.exports = router; 